home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / Mixed Mode Maddness / Emulator / Source / global.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-24  |  23.5 KB  |  1,224 lines
  1. #include "6502.h"
  2. #include "global.h"
  3. #include "stack.h"
  4.  
  5. #ifndef ____GETVALUE____
  6. #include "getValue.h"
  7. #endif
  8.  
  9. Boolean gDone = false;
  10. UInt16 pc = 0;
  11. UInt8 regA = 0, regX = 0, regY = 0, regP = 0, sp = sizeof(Page);
  12. UInt8* gStartofProg = nil;
  13.  
  14. PagePtr gMyMemoryPages = nil;
  15. UInt8* gPageZero = nil;
  16. UInt8* gStack = nil;
  17.  
  18. #define SETSTATUSBIT(bit)    regP |= bit
  19. #define CLEARSTATUSBIT(bit)    regP &= ~bit
  20. #define GETSTATUS(bit)        ((regP & bit) ? 1 : 0)
  21.  
  22. #define SETNSTATUS(reg) if (reg & NBit)    SETSTATUSBIT(NBit); else CLEARSTATUSBIT(NBit)
  23. #define SETZSTATUS(reg)    if (reg == 0)     SETSTATUSBIT(ZBit); else CLEARSTATUSBIT(ZBit)
  24.  
  25. #define UInt8ToSInt16(num)        ((num & 0x7F) * ((num & 0x80) ? -1 : 1))
  26.  
  27. #define NMI 0xFFFA                // NON MASKABLE INTERUPT VECTOR
  28. #define RES 0xFFFC                // RESET VECTOR
  29. #define IRQ    0xFFFE                // INTERUPT REQUEST VECTOR
  30.  
  31. //////////////////////////////////////////////
  32. //
  33. //    ADC        Add with Carry to A
  34. //
  35. //////////////////////////////////////////////
  36. void _ADC(UInt8 opByte)
  37. {
  38.     SInt16 l_a, h_a, l_opByte, h_opByte, l_result, h_result, result, tempA, tempopByte;
  39.  
  40.     if (GETSTATUS(DBit)) {
  41.         l_a = (regA & 0x0F);
  42.         h_a = ((regA & 0xF0) >> 4);
  43.         l_opByte = (opByte & 0x0F);
  44.         h_opByte = ((opByte & 0xF0) >> 4);
  45.  
  46.         l_result = (l_a + l_opByte + GETSTATUS(CBit));
  47.         h_result = (l_result > 9) ? (h_a + h_opByte + 1) : (h_a + h_opByte);
  48.  
  49.         if (h_result > 9) {
  50.             SETSTATUSBIT(CBit);
  51.         }
  52.         else {
  53.             CLEARSTATUSBIT(CBit);
  54.         }
  55.         regA = (((h_result % 10) << 4) + (l_result % 10));
  56.     }
  57.     else {
  58.         result = (regA + opByte + GETSTATUS(CBit));
  59.  
  60.         tempA = UInt8ToSInt16(regA);
  61.         tempopByte = UInt8ToSInt16(opByte);
  62.  
  63.         if (((tempA<128) && (tempopByte<128) && ((result%256)>127)) ||
  64.             ((tempA>127) && (tempopByte>127) && ((result%256<128)))) {
  65.             SETSTATUSBIT(VBit);
  66.         }
  67.         else {
  68.             CLEARSTATUSBIT(VBit);
  69.         }
  70.  
  71.         regA = (result % 256);
  72.         if (result > 255) {
  73.             SETSTATUSBIT(CBit);
  74.         }
  75.         else {
  76.             CLEARSTATUSBIT(CBit);
  77.         }
  78.     }
  79.     SETNSTATUS(regA);
  80.     SETZSTATUS(regA);
  81. }
  82.  
  83. //////////////////////////////////////////////
  84. //
  85. //    AND        And to A
  86. //
  87. //////////////////////////////////////////////
  88. void _AND(UInt8 opByte)
  89. {
  90.     regA &= opByte;
  91.     if (GETSTATUS(CBit)) {
  92.         ++regA;
  93.     }
  94.     SETNSTATUS(regA);
  95.     SETZSTATUS(regA);
  96. }
  97.  
  98. //////////////////////////////////////////////
  99. //
  100. //    _ASL        Arithmetic shift left
  101. //
  102. //////////////////////////////////////////////
  103. void _ASL(UInt8* addr)
  104. {
  105.     UInt8 theBye = ((*addr) << 1);
  106.     if (*addr & 0x80)
  107.         SETSTATUSBIT(CBit);
  108.     else
  109.         CLEARSTATUSBIT(CBit);
  110.  
  111.     *addr = theBye;
  112.     SETNSTATUS(theBye);
  113.     SETZSTATUS(theBye);
  114. }
  115.  
  116. //////////////////////////////////////////////
  117. //
  118. //    _BCC        Branch Carry Clear
  119. //
  120. //////////////////////////////////////////////
  121. void _BCC(UInt8 opByte)
  122. {
  123.     SInt8 theOffset = 0;
  124.     if (GETSTATUS(CBit) == 0) {
  125.         theOffset |= opByte;
  126.         if (theOffset < 0) {
  127.             pc -= (-theOffset);
  128.         }
  129.         else {
  130.             pc += theOffset;
  131.         }
  132.     }
  133. }
  134.  
  135. //////////////////////////////////////////////
  136. //
  137. //    _BCS        Branch Carry Set
  138. //
  139. //////////////////////////////////////////////
  140. void _BCS(UInt8 opByte)
  141. {
  142.     SInt8 theOffset = 0;
  143.     if (GETSTATUS(CBit)) {
  144.         theOffset |= opByte;
  145.         if (theOffset < 0) {
  146.             pc -= (-theOffset);
  147.         }
  148.         else {
  149.             pc += theOffset;
  150.         }
  151.     }
  152. }
  153.  
  154. //////////////////////////////////////////////
  155. //
  156. //    _BEQ        Branch Equal
  157. //
  158. //////////////////////////////////////////////
  159. void _BEQ(UInt8 opByte)
  160. {
  161.     SInt8 theOffset = 0;
  162.     if (GETSTATUS(ZBit)) {
  163.         theOffset |= opByte;
  164.         if (theOffset < 0) {
  165.             pc -= (-theOffset);
  166.         }
  167.         else {
  168.             pc += theOffset;
  169.         }
  170.     }
  171. }
  172.  
  173. //////////////////////////////////////////////
  174. //
  175. //    _BNE        Branch Not Equal
  176. //
  177. //////////////////////////////////////////////
  178. void _BNE(UInt8 opByte)
  179. {
  180.  
  181.     SInt8 theOffset = 0;
  182.  
  183.     if (GETSTATUS(ZBit) == 0) {
  184.         theOffset |= opByte;
  185.         if (theOffset < 0) {
  186.             pc -= (-theOffset);
  187.         }
  188.         else {
  189.             pc += theOffset;
  190.         }
  191.     }
  192. }
  193.  
  194. //////////////////////////////////////////////
  195. //
  196. //    _BMI        Branch Minus
  197. //
  198. //////////////////////////////////////////////
  199. void _BMI(UInt8 opByte)
  200. {
  201.     SInt8 theOffset = 0;
  202.     if (GETSTATUS(NBit)) {
  203.         theOffset |= opByte;
  204.         if (theOffset < 0) {
  205.             pc -= (-theOffset);
  206.         }
  207.         else {
  208.             pc += theOffset;
  209.         }
  210.     }
  211. }
  212.  
  213. //////////////////////////////////////////////
  214. //
  215. //    _BPL        Branch Plus
  216. //
  217. //////////////////////////////////////////////
  218. void _BPL(UInt8 opByte)
  219. {
  220.     SInt8 theOffset = 0;
  221.     if (GETSTATUS(NBit) == 0) {
  222.         theOffset |= opByte;
  223.         if (theOffset < 0) {
  224.             pc -= (-theOffset);
  225.         }
  226.         else {
  227.             pc += theOffset;
  228.         }
  229.     }
  230. }
  231.  
  232. //////////////////////////////////////////////
  233. //
  234. //    _BVC        Branch Overflow Clear
  235. //
  236. //////////////////////////////////////////////
  237. void _BVC(UInt8 opByte)
  238. {
  239.     SInt8 theOffset = 0;
  240.     if (GETSTATUS(VBit) == 0) {
  241.         theOffset |= opByte;
  242.         if (theOffset < 0) {
  243.             pc -= (-theOffset);
  244.         }
  245.         else {
  246.             pc += theOffset;
  247.         }
  248.     }
  249. }
  250.  
  251. //////////////////////////////////////////////
  252. //
  253. //    _BVS        Branch Overflow Set
  254. //
  255. //////////////////////////////////////////////
  256. void _BVS(UInt8 opByte)
  257. {
  258.     SInt8 theOffset = 0;
  259.     if (GETSTATUS(VBit)) {
  260.         theOffset |= opByte;
  261.         if (theOffset < 0) {
  262.             pc -= (-theOffset);
  263.         }
  264.         else {
  265.             pc += theOffset;
  266.         }
  267.     }
  268. }
  269.  
  270. //////////////////////////////////////////////
  271. //
  272. //    _BIT    And With Accumulator (A Unchanged)
  273. //
  274. //////////////////////////////////////////////
  275. void _BIT(UInt8* addr)
  276. {
  277.     UInt8 theBye = *addr;
  278.  
  279.     theBye &= regA;
  280.     SETNSTATUS(theBye);
  281.     SETZSTATUS(theBye);
  282.     if (theBye & 0x40)
  283.         SETSTATUSBIT(VBit);
  284.     else
  285.         CLEARSTATUSBIT(VBit);
  286. }
  287.  
  288. //////////////////////////////////////////////
  289. //
  290. //    _BRK        Break
  291. //
  292. //////////////////////////////////////////////
  293. void _BRK(void)
  294. {
  295.     regP |= BBit;
  296.     PushWord(pc);
  297.     PushByte(regP);
  298.     pc = IRQ;
  299.     return;
  300. }
  301.  
  302. //////////////////////////////////////////////
  303. //
  304. //    _CLC        Clear carry
  305. //
  306. //////////////////////////////////////////////
  307. void _CLC(void)
  308. {
  309.     regP &= ~CBit;
  310. }
  311.  
  312. //////////////////////////////////////////////
  313. //
  314. //    _CLD        Clear Decimal
  315. //
  316. //////////////////////////////////////////////
  317. void _CLD(void)
  318. {
  319.     regP &= ~DBit;
  320. }
  321.  
  322. //////////////////////////////////////////////
  323. //
  324. //    _CLI        Clear Interupt
  325. //
  326. //////////////////////////////////////////////
  327. void _CLI(void)
  328. {
  329.     regP &= ~IBit;
  330. }
  331.  
  332. //////////////////////////////////////////////
  333. //
  334. //    _CLV        Clear Overflow
  335. //
  336. //////////////////////////////////////////////
  337. void _CLV(void)
  338. {
  339.     regP &= ~VBit;
  340. }
  341.  
  342. //////////////////////////////////////////////
  343. //
  344. //    _CMP        Compare to A
  345. //
  346. //////////////////////////////////////////////
  347. void _CMP(UInt8 opByte)
  348. {
  349.     SInt16 tempregA, tempopByte, result;
  350.  
  351.     tempregA = UInt8ToSInt16(regA);
  352.     tempopByte = UInt8ToSInt16(opByte);
  353.     
  354.     result = tempregA - tempopByte;
  355.     if (result < 0) {
  356.         result += 256;
  357.         CLEARSTATUSBIT(CBit);
  358.     }
  359.     else {
  360.         SETSTATUSBIT(CBit);
  361.     }
  362.     SETNSTATUS(result);
  363.     SETZSTATUS(result);
  364. }
  365.  
  366. //////////////////////////////////////////////
  367. //
  368. //    _CPX        Compare to X
  369. //
  370. //////////////////////////////////////////////
  371. void _CPX(UInt8 opByte)
  372. {
  373.     SInt16 tempregX, tempopByte, result;
  374.  
  375.     tempregX = UInt8ToSInt16(regX);
  376.     tempopByte = UInt8ToSInt16(opByte);
  377.     
  378.     result = tempregX - tempopByte;
  379.     if (result < 0) {
  380.         result += 256;
  381.         CLEARSTATUSBIT(CBit);
  382.     }
  383.     else {
  384.         SETSTATUSBIT(CBit);
  385.     }
  386.     SETNSTATUS(result);
  387.     SETZSTATUS(result);
  388. }
  389.  
  390. //////////////////////////////////////////////
  391. //
  392. //    _CPY        Compare to Y
  393. //
  394. //////////////////////////////////////////////
  395. void _CPY(UInt8 opByte)
  396. {
  397.     SInt16 tempregY, tempopByte, result;
  398.  
  399.     tempregY = UInt8ToSInt16(regY);
  400.     tempopByte = UInt8ToSInt16(opByte);
  401.     
  402.     result = tempregY - tempopByte;
  403.     if (result < 0) {
  404.         result += 256;
  405.         CLEARSTATUSBIT(CBit);
  406.     }
  407.     else {
  408.         SETSTATUSBIT(CBit);
  409.     }
  410.     SETNSTATUS(result);
  411.     SETZSTATUS(result);
  412. }
  413.  
  414. //////////////////////////////////////////////
  415. //
  416. //    _DEC    Decrement by one
  417. //
  418. //////////////////////////////////////////////
  419. void _DEC(UInt8* addr)
  420. {
  421.     UInt8 theBye = *addr;
  422.  
  423.     theBye--;
  424.     SETNSTATUS(theBye);
  425.     SETZSTATUS(theBye);
  426.      *addr = theBye;
  427. }
  428.  
  429. //////////////////////////////////////////////
  430. //
  431. //    _DEX    Decrement X by one
  432. //
  433. //////////////////////////////////////////////
  434. void _DEX(void)
  435. {
  436.     regX--;
  437.     SETNSTATUS(regX);
  438.     SETZSTATUS(regX);
  439. }
  440.  
  441. //////////////////////////////////////////////
  442. //
  443. //    _DEY    Decrement Y by one
  444. //
  445. //////////////////////////////////////////////
  446. void _DEY(void)
  447. {
  448.     regY--;
  449.     SETNSTATUS(regY);
  450.     SETZSTATUS(regY);
  451. }
  452.  
  453. //////////////////////////////////////////////
  454. //
  455. //    _EOR        XOR to Y
  456. //
  457. //////////////////////////////////////////////
  458. void _EOR(UInt8 opByte)
  459. {
  460.     regA ^= opByte;
  461.  
  462.     SETNSTATUS(regA);
  463.     SETZSTATUS(regA);
  464. }
  465.  
  466. //////////////////////////////////////////////
  467. //
  468. //    _INC    Increment by one
  469. //
  470. //////////////////////////////////////////////
  471. void _INC(UInt8* addr)
  472. {
  473.     UInt8 theBye = *addr;
  474.  
  475.     theBye++;
  476.     SETNSTATUS(theBye);
  477.     SETZSTATUS(theBye);
  478.      *addr = theBye;
  479. }
  480.  
  481. //////////////////////////////////////////////
  482. //
  483. //    _INX    Increment X by one
  484. //
  485. //////////////////////////////////////////////
  486. void _INX(void)
  487. {
  488.     regX++;
  489.     SETNSTATUS(regX);
  490.     SETZSTATUS(regX);
  491. }
  492.  
  493. //////////////////////////////////////////////
  494. //
  495. //    _INY    Increment Y by one
  496. //
  497. //////////////////////////////////////////////
  498. void _INY(void)
  499. {
  500.     regY++;
  501.     SETNSTATUS(regY);
  502.     SETZSTATUS(regY);
  503. }
  504.  
  505. //////////////////////////////////////////////
  506. //
  507. //    _JMP    Jump to new location
  508. //
  509. //////////////////////////////////////////////
  510. void _JMP(UInt16 address)
  511. {
  512.     pc = address;
  513. }
  514.  
  515. //////////////////////////////////////////////
  516. //
  517. //    _JSR    Jump to SubRoutine
  518. //
  519. //////////////////////////////////////////////
  520. void _JSR(UInt16 address)
  521. {
  522.     PushWord(pc -1);
  523.     pc = address;
  524. }
  525.  
  526. //////////////////////////////////////////////
  527. //
  528. //    _LDA    Load accumulator
  529. //
  530. //////////////////////////////////////////////
  531. void _LDA(UInt8 opByte)
  532. {
  533.     regA = opByte;
  534.  
  535.     SETNSTATUS(regA);
  536.     SETZSTATUS(regA);
  537. }
  538.  
  539. //////////////////////////////////////////////
  540. //
  541. //    _LDX    Load X
  542. //
  543. //////////////////////////////////////////////
  544. void _LDX(UInt8 opByte)
  545. {
  546.     regX = opByte;
  547.  
  548.     SETNSTATUS(regX);
  549.     SETZSTATUS(regX);
  550. }
  551.  
  552. //////////////////////////////////////////////
  553. //
  554. //    _LDY    Load Y
  555. //
  556. //////////////////////////////////////////////
  557. void _LDY(UInt8 opByte)
  558. {
  559.  
  560.     regY = opByte;
  561.  
  562.     SETNSTATUS(regY);
  563.     SETZSTATUS(regY);
  564. }
  565.  
  566. //////////////////////////////////////////////
  567. //
  568. //    _LSR        Logical shift right
  569. //
  570. //////////////////////////////////////////////
  571. void _LSR(UInt8* addr)
  572. {
  573.     UInt8 theBye = ((*addr) >> 1);
  574.     if (*addr & 0x01)
  575.         SETSTATUSBIT(CBit);
  576.     else
  577.         CLEARSTATUSBIT(CBit);
  578.  
  579.     *addr = theBye;
  580.     SETNSTATUS(theBye);
  581.     SETZSTATUS(theBye);
  582. }
  583.  
  584. //////////////////////////////////////////////
  585. //
  586. //    _NOP        No operation
  587. //
  588. //////////////////////////////////////////////
  589. void _NOP(void)
  590. {
  591.     return;
  592. }
  593.  
  594. //////////////////////////////////////////////
  595. //
  596. //    _ORA    Or with Accumulator
  597. //
  598. //////////////////////////////////////////////
  599. void _ORA(UInt8 opByte)
  600. {
  601.     regA |= opByte;
  602.     SETNSTATUS(regA);
  603.     SETZSTATUS(regA);
  604. }
  605.  
  606. //////////////////////////////////////////////
  607. //
  608. //    _PHA    Push A on stack
  609. //
  610. //////////////////////////////////////////////
  611. void _PHA(void)
  612. {
  613.     PushByte(regA);
  614. }
  615.  
  616. //////////////////////////////////////////////
  617. //
  618. //    _PHP    Push P on stack
  619. //
  620. //////////////////////////////////////////////
  621. void _PHP(void)
  622. {
  623.     PushByte(regP);
  624. }
  625.  
  626. //////////////////////////////////////////////
  627. //
  628. //    _PLA    Pop A from stack
  629. //
  630. //////////////////////////////////////////////
  631. void _PLA(void)
  632. {
  633.     regA = PopByte();
  634.     SETNSTATUS(regA);
  635.     SETZSTATUS(regA);
  636. }
  637.  
  638. //////////////////////////////////////////////
  639. //
  640. //    _PLP    Pop P from stack
  641. //
  642. //////////////////////////////////////////////
  643. void _PLP(void)
  644. {
  645.     regP = PopByte();
  646. }
  647.  
  648. //////////////////////////////////////////////
  649. //
  650. //    _ROL        Rotate left through carry
  651. //
  652. //////////////////////////////////////////////
  653. void _ROL(UInt8* addr)
  654. {
  655.     UInt8 theBye = ((*addr) << 1);
  656.     
  657.     if (GETSTATUS(CBit))
  658.         theBye |= 0x01;
  659.  
  660.     if (*addr & 0x80)
  661.         SETSTATUSBIT(CBit);
  662.     else
  663.         CLEARSTATUSBIT(CBit);
  664.  
  665.     *addr = theBye;
  666.     SETNSTATUS(theBye);
  667.     SETZSTATUS(theBye);
  668. }
  669.  
  670. //////////////////////////////////////////////
  671. //
  672. //    _ROR        Rotate right through carry
  673. //
  674. //////////////////////////////////////////////
  675. void _ROR(UInt8* addr)
  676. {
  677.     UInt8 theBye = ((*addr) >> 1);
  678.     
  679.     if (GETSTATUS(CBit))
  680.         theBye |= 0x80;
  681.  
  682.     if (*addr & 0x01)
  683.         SETSTATUSBIT(CBit);
  684.     else
  685.         CLEARSTATUSBIT(CBit);
  686.  
  687.     *addr = theBye;
  688.     SETNSTATUS(theBye);
  689.     SETZSTATUS(theBye);
  690. }
  691.  
  692. //////////////////////////////////////////////
  693. //
  694. //    RTI        Return From Interupt
  695. //
  696. //////////////////////////////////////////////
  697. void _RTI(void)
  698. {
  699.     regP = PopByte();
  700.     pc = PopWord();
  701. }
  702.  
  703. //////////////////////////////////////////////
  704. //
  705. //    RTS        Return Subroutine
  706. //
  707. //////////////////////////////////////////////
  708. void _RTS(void)
  709. {
  710.     UInt8 oldsp = sp;
  711.     UInt16 addr = PopWord();
  712.  
  713.     if (oldsp < sp) {
  714.         gDone = true;
  715.         return;
  716.     }
  717.     pc = addr;
  718.     pc++;
  719. }
  720.  
  721. //////////////////////////////////////////////
  722. //
  723. //    SBC        Subtract with Carry to A
  724. //
  725. //////////////////////////////////////////////
  726. void _SBC(UInt8 opByte)
  727. {
  728.     SInt16 a_a,  a_opByte, result, tempA, tempopByte;
  729.  
  730.     if (GETSTATUS(DBit)) {
  731.         a_a = (((regA & 0xF0) >> 4) * 10) + (regA & 0x0F);
  732.         a_opByte = (((opByte & 0xF0) >> 4) * 10) + (opByte & 0x0F);
  733.         result = a_a - a_opByte;
  734.  
  735.         if (result <0) {
  736.             SETSTATUSBIT(CBit);
  737.             result = 100 - result;
  738.         }
  739.         else {
  740.             CLEARSTATUSBIT(CBit);
  741.         }
  742.         regA = ((result % 10)  + ((result / 10) << 4));
  743.     }
  744.     else {
  745.         tempA = UInt8ToSInt16(regA);
  746.         tempopByte = UInt8ToSInt16(opByte);
  747.  
  748.         result = (tempA + GETSTATUS(CBit) + (255 - tempopByte));
  749.  
  750.         tempA = UInt8ToSInt16(regA);
  751.         tempopByte = UInt8ToSInt16(opByte);
  752.  
  753.         if (((tempA<128) && (tempopByte<128) && ((result & 0xFF)>127)) ||
  754.             ((tempA>127) && (tempopByte>127) && ((result & 0xFF)<128))) {
  755.             SETSTATUSBIT(VBit);
  756.         }
  757.         else {
  758.             CLEARSTATUSBIT(VBit);
  759.         }
  760.  
  761.         if (result > 255) {
  762.             SETSTATUSBIT(CBit);
  763.         }
  764.         else {
  765.             CLEARSTATUSBIT(CBit);
  766.         }
  767.         regA = (result & 0xFF);
  768.     }
  769.     SETNSTATUS(regA);
  770.     SETZSTATUS(regA);
  771. }
  772.  
  773. //////////////////////////////////////////////
  774. //
  775. //    _SEC        Set Carry
  776. //
  777. //////////////////////////////////////////////
  778. void _SEC(void)
  779. {
  780.     regP |= CBit;
  781. }
  782.  
  783. //////////////////////////////////////////////
  784. //
  785. //    _SED        Set Decimal Mode
  786. //
  787. //////////////////////////////////////////////
  788. void _SED(void)
  789. {
  790.     regP |= DBit;
  791. }
  792.  
  793. //////////////////////////////////////////////
  794. //
  795. //    _SEI        Set IRQ Disable
  796. //
  797. //////////////////////////////////////////////
  798. void _SEI(void)
  799. {
  800.     regP |= IBit;
  801. }
  802.  
  803. //////////////////////////////////////////////
  804. //
  805. //    _STA    Store A
  806. //
  807. //////////////////////////////////////////////
  808. void _STA(UInt8* addr)
  809. {
  810.      *addr = regA;
  811. }
  812.  
  813. //////////////////////////////////////////////
  814. //
  815. //    _STX    Store X
  816. //
  817. //////////////////////////////////////////////
  818. void _STX(UInt8* addr)
  819. {
  820.      *addr = regX;
  821. }
  822.  
  823. //////////////////////////////////////////////
  824. //
  825. //    _STY    Store Y
  826. //
  827. //////////////////////////////////////////////
  828. void _STY(UInt8* addr)
  829. {
  830.      *addr = regY;
  831. }
  832.  
  833. //////////////////////////////////////////////
  834. //
  835. //    _TAX    Transfer A to X
  836. //
  837. //////////////////////////////////////////////
  838. void _TAX(void)
  839. {
  840.      regX = regA;
  841.      SETNSTATUS(regX);
  842.      SETZSTATUS(regX);
  843. }
  844.  
  845. //////////////////////////////////////////////
  846. //
  847. //    _TAY    Transfer A to Y
  848. //
  849. //////////////////////////////////////////////
  850. void _TAY(void)
  851. {
  852.      regY = regA;
  853.      SETNSTATUS(regA);
  854.      SETZSTATUS(regA);
  855. }
  856.  
  857. //////////////////////////////////////////////
  858. //
  859. //    _TSX    Transfer Stack to X
  860. //
  861. //////////////////////////////////////////////
  862. void _TSX(void)
  863. {
  864.      regX = sp;
  865.      SETNSTATUS(regX);
  866.      SETZSTATUS(regX);
  867. }
  868.  
  869. //////////////////////////////////////////////
  870. //
  871. //    _TXA    Transfer X to A
  872. //
  873. //////////////////////////////////////////////
  874. void _TXA(void)
  875. {
  876.      regA = regX;
  877.      SETNSTATUS(regA);
  878.      SETZSTATUS(regA);
  879. }
  880.  
  881. //////////////////////////////////////////////
  882. //
  883. //    _TXS    Transfer X to Stack
  884. //
  885. //////////////////////////////////////////////
  886. void _TXS(void)
  887. {
  888.      sp = regX;
  889.      SETNSTATUS(sp);
  890.      SETZSTATUS(sp);
  891. }
  892.  
  893. //////////////////////////////////////////////
  894. //
  895. //    _TYA    Transfer Y to A
  896. //
  897. //////////////////////////////////////////////
  898. void _TYA(void)
  899. {
  900.      regA = regY;
  901.      SETNSTATUS(regA);
  902.      SETZSTATUS(regA);
  903. }
  904.  
  905.  
  906.  
  907. #define OP(op, mode)                                    { ##op##_##mode, ##op, _##op##mode, #op, ##mode}
  908. #define FUNCTION_ZEROBYTE(op, mode)                        void _##op##mode(void) {_ ##op (); }
  909. #define FUNCTION_ONEBYTE(op, mode)                        void _##op##mode(void) {_ ##op (Get##mode##Value()); }
  910. #define FUNCTION_TWOBYTE(op, mode)                        void _##op##mode(void) {_ ##op (Get##mode##Address()); }
  911. #define FUNCTION_TWOBYTEPC(op, mode)                    void _##op##mode(void) {_ ##op (Get##mode##PCAddress()); }
  912.  
  913. // Create functions to deal with addressing modes
  914.  
  915. FUNCTION_ONEBYTE(ADC, Immediate)
  916. FUNCTION_ONEBYTE(ADC, Absolute)
  917. FUNCTION_ONEBYTE(ADC, ZeroPage)
  918. FUNCTION_ONEBYTE(ADC, IndX)
  919. FUNCTION_ONEBYTE(ADC, IndY)
  920. FUNCTION_ONEBYTE(ADC, ZeroPageX)
  921. FUNCTION_ONEBYTE(ADC, AbsoluteX)
  922. FUNCTION_ONEBYTE(ADC, AbsoluteY)
  923. FUNCTION_ONEBYTE(AND, Immediate)
  924. FUNCTION_ONEBYTE(AND, Absolute)
  925. FUNCTION_ONEBYTE(AND, ZeroPage)
  926. FUNCTION_ONEBYTE(AND, IndX)
  927. FUNCTION_ONEBYTE(AND, IndY)
  928. FUNCTION_ONEBYTE(AND, ZeroPageX)
  929. FUNCTION_ONEBYTE(AND, AbsoluteX)
  930. FUNCTION_ONEBYTE(AND, AbsoluteY)
  931. FUNCTION_TWOBYTE(ASL, Absolute)
  932. FUNCTION_TWOBYTE(ASL, ZeroPage)
  933. FUNCTION_TWOBYTE(ASL, Accumulator)
  934. FUNCTION_TWOBYTE(ASL, ZeroPageX)
  935. FUNCTION_TWOBYTE(ASL, AbsoluteX)
  936. FUNCTION_ONEBYTE(BCC, Relative)
  937. FUNCTION_ONEBYTE(BCS, Relative)
  938. FUNCTION_ONEBYTE(BEQ, Relative)
  939. FUNCTION_ONEBYTE(BNE, Relative)
  940. FUNCTION_ONEBYTE(BMI, Relative)
  941. FUNCTION_ONEBYTE(BPL, Relative)
  942. FUNCTION_ONEBYTE(BVC, Relative)
  943. FUNCTION_ONEBYTE(BVS, Relative)
  944. FUNCTION_TWOBYTE(BIT, Absolute)
  945. FUNCTION_TWOBYTE(BIT, ZeroPage)
  946. FUNCTION_ZEROBYTE(BRK, None)
  947. FUNCTION_ZEROBYTE(CLC, None)
  948. FUNCTION_ZEROBYTE(CLD, None)
  949. FUNCTION_ZEROBYTE(CLI, None)
  950. FUNCTION_ZEROBYTE(CLV, None)
  951. FUNCTION_ONEBYTE(CMP, Immediate)
  952. FUNCTION_ONEBYTE(CMP, Absolute)
  953. FUNCTION_ONEBYTE(CMP, ZeroPage)
  954. FUNCTION_ONEBYTE(CMP, IndX)
  955. FUNCTION_ONEBYTE(CMP, IndY)
  956. FUNCTION_ONEBYTE(CMP, ZeroPageX)
  957. FUNCTION_ONEBYTE(CMP, AbsoluteX)
  958. FUNCTION_ONEBYTE(CMP, AbsoluteY)
  959. FUNCTION_ONEBYTE(CPX, Immediate)
  960. FUNCTION_ONEBYTE(CPX, Absolute)
  961. FUNCTION_ONEBYTE(CPX, ZeroPage)
  962. FUNCTION_ONEBYTE(CPY, Immediate)
  963. FUNCTION_ONEBYTE(CPY, Absolute)
  964. FUNCTION_ONEBYTE(CPY, ZeroPage)
  965. FUNCTION_TWOBYTE(DEC, Absolute)
  966. FUNCTION_TWOBYTE(DEC, ZeroPage)
  967. FUNCTION_TWOBYTE(DEC, ZeroPageX)
  968. FUNCTION_TWOBYTE(DEC, AbsoluteX)
  969. FUNCTION_ZEROBYTE(DEX, None)
  970. FUNCTION_ZEROBYTE(DEY, None)
  971. FUNCTION_ONEBYTE(EOR, Immediate)
  972. FUNCTION_ONEBYTE(EOR, Absolute)
  973. FUNCTION_ONEBYTE(EOR, ZeroPage)
  974. FUNCTION_ONEBYTE(EOR, IndX)
  975. FUNCTION_ONEBYTE(EOR, IndY)
  976. FUNCTION_ONEBYTE(EOR, ZeroPageX)
  977. FUNCTION_ONEBYTE(EOR, AbsoluteX)
  978. FUNCTION_ONEBYTE(EOR, AbsoluteY)
  979. FUNCTION_TWOBYTE(INC, Absolute)
  980. FUNCTION_TWOBYTE(INC, ZeroPage)
  981. FUNCTION_TWOBYTE(INC, ZeroPageX)
  982. FUNCTION_TWOBYTE(INC, AbsoluteX)
  983. FUNCTION_ZEROBYTE(INX, None)
  984. FUNCTION_ZEROBYTE(INY, None)
  985. FUNCTION_TWOBYTEPC(JMP, Absolute)
  986. FUNCTION_TWOBYTEPC(JMP, Indirect)
  987. FUNCTION_TWOBYTEPC(JSR, Absolute)
  988. FUNCTION_ONEBYTE(LDA, Immediate)
  989. FUNCTION_ONEBYTE(LDA, Absolute)
  990. FUNCTION_ONEBYTE(LDA, ZeroPage)
  991. FUNCTION_ONEBYTE(LDA, IndX)
  992. FUNCTION_ONEBYTE(LDA, IndY)
  993. FUNCTION_ONEBYTE(LDA, ZeroPageX)
  994. FUNCTION_ONEBYTE(LDA, AbsoluteX)
  995. FUNCTION_ONEBYTE(LDA, AbsoluteY)
  996. FUNCTION_ONEBYTE(LDX, Immediate)
  997. FUNCTION_ONEBYTE(LDX, Absolute)
  998. FUNCTION_ONEBYTE(LDX, ZeroPage)
  999. FUNCTION_ONEBYTE(LDX, AbsoluteY)
  1000. FUNCTION_ONEBYTE(LDX, ZeroPageY)
  1001. FUNCTION_ONEBYTE(LDY, Immediate)
  1002. FUNCTION_ONEBYTE(LDY, Absolute)
  1003. FUNCTION_ONEBYTE(LDY, ZeroPage)
  1004. FUNCTION_ONEBYTE(LDY, ZeroPageX)
  1005. FUNCTION_ONEBYTE(LDY, AbsoluteX)
  1006. FUNCTION_TWOBYTE(LSR, Absolute)
  1007. FUNCTION_TWOBYTE(LSR, ZeroPage)
  1008. FUNCTION_TWOBYTE(LSR, Accumulator)
  1009. FUNCTION_TWOBYTE(LSR, ZeroPageX)
  1010. FUNCTION_TWOBYTE(LSR, AbsoluteX)
  1011. FUNCTION_ZEROBYTE(NOP, None);
  1012. FUNCTION_ONEBYTE(ORA, Immediate)
  1013. FUNCTION_ONEBYTE(ORA, Absolute)
  1014. FUNCTION_ONEBYTE(ORA, ZeroPage)
  1015. FUNCTION_ONEBYTE(ORA, IndX)
  1016. FUNCTION_ONEBYTE(ORA, IndY)
  1017. FUNCTION_ONEBYTE(ORA, ZeroPageX)
  1018. FUNCTION_ONEBYTE(ORA, AbsoluteX)
  1019. FUNCTION_ONEBYTE(ORA, AbsoluteY)
  1020. FUNCTION_ZEROBYTE(PHA, None)
  1021. FUNCTION_ZEROBYTE(PHP, None)
  1022. FUNCTION_ZEROBYTE(PLA, None)
  1023. FUNCTION_ZEROBYTE(PLP, None)
  1024. FUNCTION_TWOBYTE(ROL, Absolute)
  1025. FUNCTION_TWOBYTE(ROL, ZeroPage)
  1026. FUNCTION_TWOBYTE(ROL, Accumulator)
  1027. FUNCTION_TWOBYTE(ROL, ZeroPageX)
  1028. FUNCTION_TWOBYTE(ROL, AbsoluteX)
  1029. FUNCTION_TWOBYTE(ROR, Absolute)
  1030. FUNCTION_TWOBYTE(ROR, ZeroPage)
  1031. FUNCTION_TWOBYTE(ROR, Accumulator)
  1032. FUNCTION_TWOBYTE(ROR, ZeroPageX)
  1033. FUNCTION_TWOBYTE(ROR, AbsoluteX)
  1034. FUNCTION_ZEROBYTE(RTI, None)
  1035. FUNCTION_ZEROBYTE(RTS, None)
  1036. FUNCTION_ONEBYTE(SBC, Immediate)
  1037. FUNCTION_ONEBYTE(SBC, Absolute)
  1038. FUNCTION_ONEBYTE(SBC, ZeroPage)
  1039. FUNCTION_ONEBYTE(SBC, IndX)
  1040. FUNCTION_ONEBYTE(SBC, IndY)
  1041. FUNCTION_ONEBYTE(SBC, ZeroPageX)
  1042. FUNCTION_ONEBYTE(SBC, AbsoluteX)
  1043. FUNCTION_ONEBYTE(SBC, AbsoluteY)
  1044. FUNCTION_ZEROBYTE(SEC, None)
  1045. FUNCTION_ZEROBYTE(SED, None)
  1046. FUNCTION_ZEROBYTE(SEI, None)
  1047. FUNCTION_TWOBYTE(STA, Absolute)
  1048. FUNCTION_TWOBYTE(STA, ZeroPage)
  1049. FUNCTION_TWOBYTE(STA, IndX)
  1050. FUNCTION_TWOBYTE(STA, IndY)
  1051. FUNCTION_TWOBYTE(STA, ZeroPageX)
  1052. FUNCTION_TWOBYTE(STA, AbsoluteX)
  1053. FUNCTION_TWOBYTE(STA, AbsoluteY)
  1054. FUNCTION_TWOBYTE(STX, Absolute)
  1055. FUNCTION_TWOBYTE(STX, ZeroPage)
  1056. FUNCTION_TWOBYTE(STX, ZeroPageY)
  1057. FUNCTION_TWOBYTE(STY, Absolute)
  1058. FUNCTION_TWOBYTE(STY, ZeroPage)
  1059. FUNCTION_TWOBYTE(STY, ZeroPageX)
  1060. FUNCTION_ZEROBYTE(TAX, None)
  1061. FUNCTION_ZEROBYTE(TAY, None)
  1062. FUNCTION_ZEROBYTE(TSX, None)
  1063. FUNCTION_ZEROBYTE(TXA, None)
  1064. FUNCTION_ZEROBYTE(TXS, None)
  1065. FUNCTION_ZEROBYTE(TYA, None)
  1066.  
  1067. // create opcode table with functions
  1068. OpTable gOpCodeBase[] = {
  1069.     OP(ADC, Immediate),
  1070.     OP(ADC, Absolute),
  1071.     OP(ADC, ZeroPage),
  1072.     OP(ADC, IndX),
  1073.     OP(ADC, IndY),
  1074.     OP(ADC, ZeroPageX),
  1075.     OP(ADC, AbsoluteX),
  1076.     OP(ADC, AbsoluteY),
  1077.     OP(AND, Immediate),
  1078.     OP(AND, Absolute),
  1079.     OP(AND, ZeroPage),
  1080.     OP(AND, IndX),
  1081.     OP(AND, IndY),
  1082.     OP(AND, ZeroPageX),
  1083.     OP(AND, AbsoluteX),
  1084.     OP(AND, AbsoluteY),
  1085.     OP(ASL, Absolute),
  1086.     OP(ASL, ZeroPage),
  1087.     OP(ASL, Accumulator),
  1088.     OP(ASL, ZeroPageX),
  1089.     OP(ASL, AbsoluteX),
  1090.     OP(BCC, Relative),
  1091.     OP(BCS, Relative),
  1092.     OP(BEQ, Relative),
  1093.     OP(BNE, Relative),
  1094.     OP(BMI, Relative),
  1095.     OP(BPL, Relative),
  1096.     OP(BVC, Relative),
  1097.     OP(BVS, Relative),
  1098.     OP(BIT, Absolute),
  1099.     OP(BIT, ZeroPage),
  1100.     OP(BRK, None),
  1101.     OP(CLC, None),
  1102.     OP(CLD, None),
  1103.     OP(CLI, None),
  1104.     OP(CLV, None),
  1105.     OP(CMP, Immediate),
  1106.     OP(CMP, Absolute),
  1107.     OP(CMP, ZeroPage),
  1108.     OP(CMP, IndX),
  1109.     OP(CMP, IndY),
  1110.     OP(CMP, ZeroPageX),
  1111.     OP(CMP, AbsoluteX),
  1112.     OP(CMP, AbsoluteY),
  1113.     OP(CPX, Immediate),
  1114.     OP(CPX, Absolute),
  1115.     OP(CPX, ZeroPage),
  1116.     OP(CPY, Immediate),
  1117.     OP(CPY, Absolute),
  1118.     OP(CPY, ZeroPage),
  1119.     OP(DEC, Absolute),
  1120.     OP(DEC, ZeroPage),
  1121.     OP(DEC, ZeroPageX),
  1122.     OP(DEC, AbsoluteX),
  1123.     OP(DEX, None),
  1124.     OP(DEY, None),
  1125.     OP(EOR, Immediate),
  1126.     OP(EOR, Absolute),
  1127.     OP(EOR, ZeroPage),
  1128.     OP(EOR, IndX),
  1129.     OP(EOR, IndY),
  1130.     OP(EOR, ZeroPageX),
  1131.     OP(EOR, AbsoluteX),
  1132.     OP(EOR, AbsoluteY),
  1133.     OP(INC, Absolute),
  1134.     OP(INC, ZeroPage),
  1135.     OP(INC, ZeroPageX),
  1136.     OP(INC, AbsoluteX),
  1137.     OP(INX, None),
  1138.     OP(INY, None),
  1139.     OP(JMP, Absolute),
  1140.     OP(JMP, Indirect),
  1141.     OP(JSR, Absolute),
  1142.     OP(LDA, Immediate),
  1143.     OP(LDA, Absolute),
  1144.     OP(LDA, ZeroPage),
  1145.     OP(LDA, IndX),
  1146.     OP(LDA, IndY),
  1147.     OP(LDA, ZeroPageX),
  1148.     OP(LDA, AbsoluteX),
  1149.     OP(LDA, AbsoluteY),
  1150.     OP(LDX, Immediate),
  1151.     OP(LDX, Absolute),
  1152.     OP(LDX, ZeroPage),
  1153.     OP(LDX, AbsoluteY),
  1154.     OP(LDX, ZeroPageY),
  1155.     OP(LDY, Immediate),
  1156.     OP(LDY, Absolute),
  1157.     OP(LDY, ZeroPage),
  1158.     OP(LDY, ZeroPageX),
  1159.     OP(LDY, AbsoluteX),
  1160.     OP(LSR, Absolute),
  1161.     OP(LSR, ZeroPage),
  1162.     OP(LSR, Accumulator),
  1163.     OP(LSR, ZeroPageX),
  1164.     OP(LSR, AbsoluteX),
  1165.     OP(NOP, None),
  1166.     OP(ORA, Immediate),
  1167.     OP(ORA, Absolute),
  1168.     OP(ORA, ZeroPage),
  1169.     OP(ORA, IndX),
  1170.     OP(ORA, IndY),
  1171.     OP(ORA, ZeroPageX),
  1172.     OP(ORA, AbsoluteX),
  1173.     OP(ORA, AbsoluteY),
  1174.     OP(PHA, None),
  1175.     OP(PHP, None),
  1176.     OP(PLA, None),
  1177.     OP(PLP, None),
  1178.     OP(ROL, Absolute),
  1179.     OP(ROL, ZeroPage),
  1180.     OP(ROL, Accumulator),
  1181.     OP(ROL, ZeroPageX),
  1182.     OP(ROL, AbsoluteX),
  1183.     OP(ROR, Absolute),
  1184.     OP(ROR, ZeroPage),
  1185.     OP(ROR, Accumulator),
  1186.     OP(ROR, ZeroPageX),
  1187.     OP(ROR, AbsoluteX),
  1188.     OP(RTI, None),
  1189.     OP(RTS, None),
  1190.     OP(SBC, Immediate),
  1191.     OP(SBC, Absolute),
  1192.     OP(SBC, ZeroPage),
  1193.     OP(SBC, IndX),
  1194.     OP(SBC, IndY),
  1195.     OP(SBC, ZeroPageX),
  1196.     OP(SBC, AbsoluteX),
  1197.     OP(SBC, AbsoluteY),
  1198.     OP(SEC, None),
  1199.     OP(SED, None),
  1200.     OP(SEI, None),
  1201.     OP(STA, Absolute),
  1202.     OP(STA, ZeroPage),
  1203.     OP(STA, IndX),
  1204.     OP(STA, IndY),
  1205.     OP(STA, ZeroPageX),
  1206.     OP(STA, AbsoluteX),
  1207.     OP(STA, AbsoluteY),
  1208.     OP(STX, Absolute),
  1209.     OP(STX, ZeroPage),
  1210.     OP(STX, ZeroPageY),
  1211.     OP(STY, Absolute),
  1212.     OP(STY, ZeroPage),
  1213.     OP(STY, ZeroPageX),
  1214.     OP(TAX, None),
  1215.     OP(TAY, None),
  1216.     OP(TSX, None),
  1217.     OP(TXA, None),
  1218.     OP(TXS, None),
  1219.     OP(TYA, None)
  1220. };
  1221. #define kNumOpCodes sizeof(gOpCodeBase) / sizeof(OpTable)
  1222. UInt8 gNumOpCodes = kNumOpCodes;
  1223.  
  1224.